
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html><head><title>Python: module alea</title>
<meta charset="utf-8">
</head><body bgcolor="#f0f0f8">

<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="heading">
<tr bgcolor="#7799ee">
<td valign=bottom>&nbsp;<br>
<font color="#ffffff" face="helvetica, arial">&nbsp;<br><big><big><strong>alea</strong></big></big></font></td
><td align=right valign=bottom
><font color="#ffffff" face="helvetica, arial"><a href=".">index</a><br><a href="file:/Users/admin/Documents/lea2/alea.py">/Users/admin/Documents/lea2/alea.py</a></font></td></tr></table>
    <p><tt>--------------------------------------------------------------------------------<br>
&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;alea.py<br>
&nbsp;<br>
--------------------------------------------------------------------------------<br>
Copyright&nbsp;2013,&nbsp;2014,&nbsp;2015&nbsp;Pierre&nbsp;Denis<br>
&nbsp;<br>
This&nbsp;file&nbsp;is&nbsp;part&nbsp;of&nbsp;<a href="lea.html#Lea">Lea</a>.<br>
&nbsp;<br>
<a href="lea.html#Lea">Lea</a>&nbsp;is&nbsp;free&nbsp;software:&nbsp;you&nbsp;can&nbsp;redistribute&nbsp;it&nbsp;and/or&nbsp;modify<br>
it&nbsp;under&nbsp;the&nbsp;terms&nbsp;of&nbsp;the&nbsp;GNU&nbsp;Lesser&nbsp;General&nbsp;Public&nbsp;License&nbsp;as&nbsp;published&nbsp;by<br>
the&nbsp;Free&nbsp;Software&nbsp;Foundation,&nbsp;either&nbsp;version&nbsp;3&nbsp;of&nbsp;the&nbsp;License,&nbsp;or<br>
(at&nbsp;your&nbsp;option)&nbsp;any&nbsp;later&nbsp;version.<br>
&nbsp;<br>
<a href="lea.html#Lea">Lea</a>&nbsp;is&nbsp;distributed&nbsp;in&nbsp;the&nbsp;hope&nbsp;that&nbsp;it&nbsp;will&nbsp;be&nbsp;useful,<br>
but&nbsp;WITHOUT&nbsp;ANY&nbsp;WARRANTY;&nbsp;without&nbsp;even&nbsp;the&nbsp;implied&nbsp;warranty&nbsp;of<br>
MERCHANTABILITY&nbsp;or&nbsp;FITNESS&nbsp;FOR&nbsp;A&nbsp;PARTICULAR&nbsp;PURPOSE.&nbsp;&nbsp;See&nbsp;the<br>
GNU&nbsp;Lesser&nbsp;General&nbsp;Public&nbsp;License&nbsp;for&nbsp;more&nbsp;details.<br>
&nbsp;<br>
You&nbsp;should&nbsp;have&nbsp;received&nbsp;a&nbsp;copy&nbsp;of&nbsp;the&nbsp;GNU&nbsp;Lesser&nbsp;General&nbsp;Public&nbsp;License<br>
along&nbsp;with&nbsp;<a href="lea.html#Lea">Lea</a>.&nbsp;&nbsp;If&nbsp;not,&nbsp;see&nbsp;&lt;<a href="http://www.gnu.org/licenses/">http://www.gnu.org/licenses/</a>&gt;.<br>
--------------------------------------------------------------------------------</tt></p>
<p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#aa55cc">
<td colspan=3 valign=bottom>&nbsp;<br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Modules</strong></big></font></td></tr>
    
<tr><td bgcolor="#aa55cc"><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</tt></td><td>&nbsp;</td>
<td width="100%"><table width="100%" summary="list"><tr><td width="25%" valign=top><a href="operator.html">operator</a><br>
</td><td width="25%" valign=top><a href="sys.html">sys</a><br>
</td><td width="25%" valign=top></td><td width="25%" valign=top></td></tr></table></td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ee77aa">
<td colspan=3 valign=bottom>&nbsp;<br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Classes</strong></big></font></td></tr>
    
<tr><td bgcolor="#ee77aa"><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</tt></td><td>&nbsp;</td>
<td width="100%"><dl>
<dt><font face="helvetica, arial"><a href="lea.html#Lea">lea.Lea</a>(<a href="__builtin__.html#object">__builtin__.object</a>)
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="alea.html#Alea">Alea</a>
</font></dt></dl>
</dd>
</dl>
 <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom>&nbsp;<br>
<font color="#000000" face="helvetica, arial"><a name="Alea">class <strong>Alea</strong></a>(<a href="lea.html#Lea">lea.Lea</a>)</font></td></tr>
    
<tr bgcolor="#ffc8d8"><td rowspan=2><tt>&nbsp;&nbsp;&nbsp;</tt></td>
<td colspan=2><tt><a href="#Alea">Alea</a>&nbsp;is&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;subclass,&nbsp;which&nbsp;instance&nbsp;is&nbsp;defined&nbsp;by&nbsp;explicit&nbsp;probability&nbsp;distribution&nbsp;data.<br>
An&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;is&nbsp;defined&nbsp;by&nbsp;given&nbsp;value-probability&nbsp;pairs.&nbsp;Each&nbsp;probability&nbsp;is<br>
defined&nbsp;as&nbsp;a&nbsp;positive&nbsp;"counter"&nbsp;or&nbsp;"weight"&nbsp;integer,&nbsp;without&nbsp;upper&nbsp;limit.&nbsp;The&nbsp;actual<br>
probabilities&nbsp;are&nbsp;calculated&nbsp;by&nbsp;dividing&nbsp;the&nbsp;counters&nbsp;by&nbsp;the&nbsp;sum&nbsp;of&nbsp;all&nbsp;counters.<br>&nbsp;</tt></td></tr>
<tr><td>&nbsp;</td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="alea.html#Alea">Alea</a></dd>
<dd><a href="lea.html#Lea">lea.Lea</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="Alea-__init__"><strong>__init__</strong></a>(self, vps)</dt><dd><tt>initializes&nbsp;<a href="#Alea">Alea</a>&nbsp;instance's&nbsp;attributes</tt></dd></dl>

<dl><dt><a name="Alea-__str__"><strong>__str__</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;string&nbsp;representation&nbsp;of&nbsp;probability&nbsp;distribution&nbsp;self;<br>
it&nbsp;contains&nbsp;one&nbsp;line&nbsp;per&nbsp;distinct&nbsp;value,&nbsp;separated&nbsp;by&nbsp;a&nbsp;newline&nbsp;character;<br>
each&nbsp;line&nbsp;contains&nbsp;the&nbsp;string&nbsp;representation&nbsp;of&nbsp;a&nbsp;value&nbsp;&nbsp;with&nbsp;its<br>
probability&nbsp;expressed&nbsp;as&nbsp;a&nbsp;rational&nbsp;number&nbsp;"n/d"&nbsp;or&nbsp;"0"&nbsp;or&nbsp;"1";<br>
if&nbsp;an&nbsp;order&nbsp;relationship&nbsp;is&nbsp;defined&nbsp;on&nbsp;values,&nbsp;then&nbsp;the&nbsp;values&nbsp;are&nbsp;sorted&nbsp;by&nbsp;<br>
increasing&nbsp;order;&nbsp;otherwise,&nbsp;an&nbsp;arbitrary&nbsp;order&nbsp;is&nbsp;used;<br>
called&nbsp;on&nbsp;evalution&nbsp;of&nbsp;"str(self)"&nbsp;and&nbsp;"repr(self)"</tt></dd></dl>

<dl><dt><a name="Alea-asFloat"><strong>asFloat</strong></a>(self, nbDecimals<font color="#909090">=6</font>)</dt><dd><tt>returns&nbsp;a&nbsp;string&nbsp;representation&nbsp;of&nbsp;probability&nbsp;distribution&nbsp;self;<br>
it&nbsp;contains&nbsp;one&nbsp;line&nbsp;per&nbsp;distinct&nbsp;value,&nbsp;separated&nbsp;by&nbsp;a&nbsp;newline&nbsp;character;<br>
each&nbsp;line&nbsp;contains&nbsp;the&nbsp;string&nbsp;representation&nbsp;of&nbsp;a&nbsp;value&nbsp;with&nbsp;its<br>
probability&nbsp;expressed&nbsp;as&nbsp;decimal&nbsp;with&nbsp;given&nbsp;nbDecimals&nbsp;digits;<br>
if&nbsp;an&nbsp;order&nbsp;relationship&nbsp;is&nbsp;defined&nbsp;on&nbsp;values,&nbsp;then&nbsp;the&nbsp;values&nbsp;are&nbsp;sorted&nbsp;by&nbsp;<br>
increasing&nbsp;order;&nbsp;otherwise,&nbsp;an&nbsp;arbitrary&nbsp;order&nbsp;is&nbsp;used;</tt></dd></dl>

<dl><dt><a name="Alea-asPct"><strong>asPct</strong></a>(self, nbDecimals<font color="#909090">=1</font>)</dt><dd><tt>returns&nbsp;a&nbsp;string&nbsp;representation&nbsp;of&nbsp;probability&nbsp;distribution&nbsp;self;<br>
it&nbsp;contains&nbsp;one&nbsp;line&nbsp;per&nbsp;distinct&nbsp;value,&nbsp;separated&nbsp;by&nbsp;a&nbsp;newline&nbsp;character;<br>
each&nbsp;line&nbsp;contains&nbsp;the&nbsp;string&nbsp;representation&nbsp;of&nbsp;a&nbsp;value&nbsp;with&nbsp;its<br>
probability&nbsp;expressed&nbsp;as&nbsp;percentage&nbsp;with&nbsp;given&nbsp;nbDecimals&nbsp;digits;<br>
if&nbsp;an&nbsp;order&nbsp;relationship&nbsp;is&nbsp;defined&nbsp;on&nbsp;values,&nbsp;then&nbsp;the&nbsp;values&nbsp;are&nbsp;sorted&nbsp;by&nbsp;<br>
increasing&nbsp;order;&nbsp;otherwise,&nbsp;an&nbsp;arbitrary&nbsp;order&nbsp;is&nbsp;used;</tt></dd></dl>

<dl><dt><a name="Alea-asString"><strong>asString</strong></a>(self, kind<font color="#909090">='/'</font>, nbDecimals<font color="#909090">=6</font>, histoSize<font color="#909090">=100</font>)</dt><dd><tt>returns&nbsp;a&nbsp;string&nbsp;representation&nbsp;of&nbsp;probability&nbsp;distribution&nbsp;self;<br>
it&nbsp;contains&nbsp;one&nbsp;line&nbsp;per&nbsp;distinct&nbsp;value,&nbsp;separated&nbsp;by&nbsp;a&nbsp;newline&nbsp;character;<br>
each&nbsp;line&nbsp;contains&nbsp;the&nbsp;string&nbsp;representation&nbsp;of&nbsp;a&nbsp;value&nbsp;with&nbsp;its<br>
probability&nbsp;in&nbsp;a&nbsp;format&nbsp;depending&nbsp;of&nbsp;given&nbsp;kind,&nbsp;which&nbsp;is&nbsp;string&nbsp;among<br>
'/',&nbsp;'.',&nbsp;'%',&nbsp;'-',&nbsp;'/-',&nbsp;'.-',&nbsp;'%-';&nbsp;<br>
the&nbsp;probabilities&nbsp;are&nbsp;displayed&nbsp;as<br>
-&nbsp;if&nbsp;kind[0]&nbsp;is&nbsp;'/'&nbsp;:&nbsp;rational&nbsp;numbers&nbsp;"n/d"&nbsp;or&nbsp;"0"&nbsp;or&nbsp;"1"<br>
-&nbsp;if&nbsp;kind[0]&nbsp;is&nbsp;'.'&nbsp;:&nbsp;decimals&nbsp;with&nbsp;given&nbsp;nbDecimals&nbsp;digits<br>
-&nbsp;if&nbsp;kind[0]&nbsp;is&nbsp;'%'&nbsp;:&nbsp;percentage&nbsp;decimals&nbsp;with&nbsp;given&nbsp;nbDecimals&nbsp;digits<br>
-&nbsp;if&nbsp;kind[0]&nbsp;is&nbsp;'-'&nbsp;:&nbsp;histogram&nbsp;bar&nbsp;made&nbsp;up&nbsp;of&nbsp;repeated&nbsp;'-',&nbsp;such&nbsp;that<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;a&nbsp;bar&nbsp;length&nbsp;of&nbsp;histoSize&nbsp;represents&nbsp;a&nbsp;probability&nbsp;1&nbsp;<br>
if&nbsp;kind[1]&nbsp;is&nbsp;'-',&nbsp;the&nbsp;histogram&nbsp;bars&nbsp;with&nbsp;'-'&nbsp;are&nbsp;appended&nbsp;after&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;numerical&nbsp;representation&nbsp;of&nbsp;probabilities<br>
if&nbsp;an&nbsp;order&nbsp;relationship&nbsp;is&nbsp;defined&nbsp;on&nbsp;values,&nbsp;then&nbsp;the&nbsp;values&nbsp;are&nbsp;sorted&nbsp;by&nbsp;<br>
increasing&nbsp;order;&nbsp;otherwise,&nbsp;an&nbsp;arbitrary&nbsp;order&nbsp;is&nbsp;used</tt></dd></dl>

<dl><dt><a name="Alea-cumul"><strong>cumul</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;tuple&nbsp;with&nbsp;the&nbsp;probability&nbsp;weights&nbsp;p&nbsp;that&nbsp;self&nbsp;&lt;=&nbsp;value&nbsp;;<br>
there&nbsp;is&nbsp;one&nbsp;element&nbsp;more&nbsp;than&nbsp;number&nbsp;of&nbsp;values;&nbsp;the&nbsp;first&nbsp;element&nbsp;is&nbsp;0,&nbsp;then<br>
the&nbsp;sequence&nbsp;follows&nbsp;the&nbsp;order&nbsp;defined&nbsp;on&nbsp;values;&nbsp;if&nbsp;an&nbsp;order&nbsp;relationship&nbsp;is&nbsp;defined<br>
on&nbsp;values,&nbsp;then&nbsp;the&nbsp;tuples&nbsp;follows&nbsp;their&nbsp;increasing&nbsp;order;&nbsp;otherwise,&nbsp;an&nbsp;arbitrary<br>
order&nbsp;is&nbsp;used,&nbsp;fixed&nbsp;from&nbsp;call&nbsp;to&nbsp;call<br>
Note&nbsp;:&nbsp;the&nbsp;returned&nbsp;value&nbsp;is&nbsp;cached</tt></dd></dl>

<dl><dt><a name="Alea-entropy"><strong>entropy</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;float&nbsp;number&nbsp;representing&nbsp;the&nbsp;entropy&nbsp;of&nbsp;the&nbsp;probability&nbsp;&nbsp;distribution<br>
WARNING:&nbsp;this&nbsp;method&nbsp;is&nbsp;called&nbsp;without&nbsp;parentheses</tt></dd></dl>

<dl><dt><a name="Alea-getAleaClone"><strong>getAleaClone</strong></a>(self)</dt><dd><tt>same&nbsp;as&nbsp;getAlea&nbsp;method,&nbsp;excepting&nbsp;if&nbsp;applied&nbsp;on&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance:<br>
in&nbsp;this&nbsp;case,&nbsp;a&nbsp;clone&nbsp;of&nbsp;the&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;is&nbsp;returned&nbsp;(insead&nbsp;of&nbsp;itself)</tt></dd></dl>

<dl><dt><a name="Alea-getAleaLeavesSet"><strong>getAleaLeavesSet</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;set&nbsp;containing&nbsp;all&nbsp;the&nbsp;<a href="#Alea">Alea</a>&nbsp;leaves&nbsp;in&nbsp;the&nbsp;tree&nbsp;having&nbsp;the&nbsp;root&nbsp;self<br>
in&nbsp;the&nbsp;present&nbsp;case&nbsp;of&nbsp;<a href="#Alea">Alea</a>&nbsp;instance,&nbsp;it&nbsp;returns&nbsp;the&nbsp;singleton&nbsp;set&nbsp;with&nbsp;self&nbsp;as&nbsp;element</tt></dd></dl>

<dl><dt><a name="Alea-histo"><strong>histo</strong></a>(self, size<font color="#909090">=100</font>)</dt><dd><tt>returns&nbsp;a&nbsp;string&nbsp;representation&nbsp;of&nbsp;probability&nbsp;distribution&nbsp;self;<br>
it&nbsp;contains&nbsp;one&nbsp;line&nbsp;per&nbsp;distinct&nbsp;value,&nbsp;separated&nbsp;by&nbsp;a&nbsp;newline&nbsp;character;<br>
each&nbsp;line&nbsp;contains&nbsp;the&nbsp;string&nbsp;representation&nbsp;of&nbsp;a&nbsp;value&nbsp;with&nbsp;its<br>
probability&nbsp;expressed&nbsp;as&nbsp;a&nbsp;histogram&nbsp;bar&nbsp;made&nbsp;up&nbsp;of&nbsp;repeated&nbsp;'-',<br>
such&nbsp;that&nbsp;a&nbsp;bar&nbsp;length&nbsp;of&nbsp;given&nbsp;size&nbsp;represents&nbsp;a&nbsp;probability&nbsp;1<br>
if&nbsp;an&nbsp;order&nbsp;relationship&nbsp;is&nbsp;defined&nbsp;on&nbsp;values,&nbsp;then&nbsp;the&nbsp;values&nbsp;are&nbsp;sorted&nbsp;by&nbsp;<br>
increasing&nbsp;order;&nbsp;otherwise,&nbsp;an&nbsp;arbitrary&nbsp;order&nbsp;is&nbsp;used;</tt></dd></dl>

<dl><dt><a name="Alea-invCumul"><strong>invCumul</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;tuple&nbsp;with&nbsp;the&nbsp;probability&nbsp;weights&nbsp;p&nbsp;that&nbsp;self&nbsp;&gt;=&nbsp;value&nbsp;;<br>
there&nbsp;is&nbsp;one&nbsp;element&nbsp;more&nbsp;than&nbsp;number&nbsp;of&nbsp;values;&nbsp;the&nbsp;first&nbsp;element&nbsp;is&nbsp;0,&nbsp;then<br>
the&nbsp;sequence&nbsp;follows&nbsp;the&nbsp;order&nbsp;defined&nbsp;on&nbsp;values;&nbsp;if&nbsp;an&nbsp;order&nbsp;relationship&nbsp;is&nbsp;defined<br>
on&nbsp;values,&nbsp;then&nbsp;the&nbsp;tuples&nbsp;follows&nbsp;their&nbsp;increasing&nbsp;order;&nbsp;otherwise,&nbsp;an&nbsp;arbitrary<br>
order&nbsp;is&nbsp;used,&nbsp;fixed&nbsp;from&nbsp;call&nbsp;to&nbsp;call<br>
Note&nbsp;:&nbsp;the&nbsp;returned&nbsp;value&nbsp;is&nbsp;cached</tt></dd></dl>

<dl><dt><a name="Alea-mean"><strong>mean</strong></a>(self)</dt><dd><tt>returns&nbsp;the&nbsp;mean&nbsp;value&nbsp;of&nbsp;the&nbsp;probability&nbsp;distribution,&nbsp;which&nbsp;is&nbsp;the<br>
probability&nbsp;weighted&nbsp;sum&nbsp;of&nbsp;the&nbsp;values;<br>
requires&nbsp;that<br>
1&nbsp;-&nbsp;the&nbsp;values&nbsp;can&nbsp;be&nbsp;subtracted&nbsp;together,<br>
2&nbsp;-&nbsp;the&nbsp;differences&nbsp;of&nbsp;values&nbsp;can&nbsp;be&nbsp;multiplied&nbsp;by&nbsp;integers,<br>
3&nbsp;-&nbsp;the&nbsp;differences&nbsp;of&nbsp;values&nbsp;multiplied&nbsp;by&nbsp;integers&nbsp;can&nbsp;be<br>
&nbsp;&nbsp;&nbsp;&nbsp;added&nbsp;to&nbsp;the&nbsp;values,<br>
4&nbsp;-&nbsp;the&nbsp;sum&nbsp;of&nbsp;values&nbsp;calculated&nbsp;in&nbsp;3&nbsp;can&nbsp;be&nbsp;divided&nbsp;by&nbsp;a&nbsp;float<br>
&nbsp;&nbsp;&nbsp;&nbsp;or&nbsp;an&nbsp;integer;<br>
if&nbsp;any&nbsp;of&nbsp;these&nbsp;conditions&nbsp;is&nbsp;not&nbsp;met,&nbsp;then&nbsp;the&nbsp;result&nbsp;depends&nbsp;of&nbsp;the<br>
value&nbsp;class&nbsp;implementation&nbsp;(likely,&nbsp;raised&nbsp;exception)<br>
WARNING:&nbsp;this&nbsp;method&nbsp;is&nbsp;called&nbsp;without&nbsp;parentheses</tt></dd></dl>

<dl><dt><a name="Alea-mode"><strong>mode</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;tuple&nbsp;with&nbsp;the&nbsp;value(s)&nbsp;of&nbsp;the&nbsp;probability&nbsp;distribution&nbsp;having&nbsp;the&nbsp;highest&nbsp;probability&nbsp;<br>
WARNING:&nbsp;this&nbsp;method&nbsp;is&nbsp;called&nbsp;without&nbsp;parentheses</tt></dd></dl>

<dl><dt><a name="Alea-pCumul"><strong>pCumul</strong></a>(self, *args)</dt><dd><tt>returns,&nbsp;as&nbsp;an&nbsp;integer,&nbsp;the&nbsp;probability&nbsp;weight&nbsp;that&nbsp;self&nbsp;&lt;=&nbsp;val<br>
note&nbsp;that&nbsp;it&nbsp;is&nbsp;not&nbsp;required&nbsp;that&nbsp;val&nbsp;is&nbsp;in&nbsp;the&nbsp;support&nbsp;of&nbsp;self</tt></dd></dl>

<dl><dt><a name="Alea-pInvCumul"><strong>pInvCumul</strong></a>(self, *args)</dt><dd><tt>returns,&nbsp;as&nbsp;an&nbsp;integer,&nbsp;the&nbsp;probability&nbsp;weight&nbsp;that&nbsp;self&nbsp;&gt;=&nbsp;val<br>
note&nbsp;that&nbsp;it&nbsp;is&nbsp;not&nbsp;required&nbsp;that&nbsp;val&nbsp;is&nbsp;in&nbsp;the&nbsp;support&nbsp;of&nbsp;self</tt></dd></dl>

<dl><dt><a name="Alea-randomDraw"><strong>randomDraw</strong></a>(self, n<font color="#909090">=None</font>, sorted<font color="#909090">=False</font>)</dt><dd><tt>if&nbsp;n&nbsp;is&nbsp;None,&nbsp;returns&nbsp;a&nbsp;tuple&nbsp;with&nbsp;all&nbsp;the&nbsp;values&nbsp;of&nbsp;the&nbsp;distribution,<br>
in&nbsp;a&nbsp;random&nbsp;order&nbsp;respecting&nbsp;the&nbsp;probabilities<br>
(the&nbsp;higher&nbsp;count&nbsp;of&nbsp;a&nbsp;value,&nbsp;the&nbsp;most&nbsp;likely&nbsp;the&nbsp;value&nbsp;will&nbsp;be&nbsp;in&nbsp;the<br>
&nbsp;beginning&nbsp;of&nbsp;the&nbsp;sequence)<br>
if&nbsp;n&nbsp;&gt;&nbsp;0,&nbsp;then&nbsp;only&nbsp;n&nbsp;different&nbsp;values&nbsp;will&nbsp;be&nbsp;drawn<br>
if&nbsp;sorted&nbsp;is&nbsp;True,&nbsp;then&nbsp;the&nbsp;returned&nbsp;tuple&nbsp;is&nbsp;sorted</tt></dd></dl>

<dl><dt><a name="Alea-randomIter"><strong>randomIter</strong></a>(self)</dt><dd><tt>generates&nbsp;an&nbsp;infinite&nbsp;sequence&nbsp;of&nbsp;random&nbsp;values&nbsp;among&nbsp;the&nbsp;values&nbsp;of&nbsp;self,<br>
according&nbsp;to&nbsp;their&nbsp;probabilities</tt></dd></dl>

<dl><dt><a name="Alea-randomVal"><strong>randomVal</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;random&nbsp;value&nbsp;among&nbsp;the&nbsp;values&nbsp;of&nbsp;self,&nbsp;according&nbsp;to&nbsp;their&nbsp;probabilities</tt></dd></dl>

<dl><dt><a name="Alea-std"><strong>std</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;float&nbsp;number&nbsp;representing&nbsp;the&nbsp;standard&nbsp;deviation&nbsp;of&nbsp;the&nbsp;probability&nbsp;distribution<br>
requires&nbsp;that&nbsp;the&nbsp;requirements&nbsp;of&nbsp;the&nbsp;variance()&nbsp;method&nbsp;are&nbsp;met<br>
WARNING:&nbsp;this&nbsp;method&nbsp;is&nbsp;called&nbsp;without&nbsp;parentheses</tt></dd></dl>

<dl><dt><a name="Alea-var"><strong>var</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;float&nbsp;number&nbsp;representing&nbsp;the&nbsp;variance&nbsp;of&nbsp;the&nbsp;probability&nbsp;distribution;<br>
requires&nbsp;that<br>
1&nbsp;-&nbsp;the&nbsp;requirements&nbsp;of&nbsp;the&nbsp;<a href="#Alea-mean">mean</a>()&nbsp;method&nbsp;are&nbsp;met,<br>
2&nbsp;-&nbsp;the&nbsp;values&nbsp;can&nbsp;be&nbsp;subtracted&nbsp;to&nbsp;the&nbsp;mean&nbsp;value,<br>
3&nbsp;-&nbsp;the&nbsp;differences&nbsp;between&nbsp;values&nbsp;and&nbsp;the&nbsp;mean&nbsp;value&nbsp;can&nbsp;be&nbsp;squared;<br>
if&nbsp;any&nbsp;of&nbsp;these&nbsp;conditions&nbsp;is&nbsp;not&nbsp;met,&nbsp;then&nbsp;the&nbsp;result&nbsp;depends&nbsp;of&nbsp;the<br>
value&nbsp;implementation&nbsp;(likely,&nbsp;raised&nbsp;exception)<br>
WARNING:&nbsp;this&nbsp;method&nbsp;is&nbsp;called&nbsp;without&nbsp;parentheses</tt></dd></dl>

<hr>
Static methods defined here:<br>
<dl><dt><a name="Alea-fastExtremum"><strong>fastExtremum</strong></a>(cumulFunc, *aleaArgs)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;giving&nbsp;the&nbsp;probabilities&nbsp;to&nbsp;have&nbsp;the&nbsp;extremum<br>
value&nbsp;(min&nbsp;or&nbsp;max)&nbsp;of&nbsp;each&nbsp;combination&nbsp;of&nbsp;the&nbsp;given&nbsp;<a href="#Alea">Alea</a>&nbsp;args;<br>
cumulFunc&nbsp;is&nbsp;the&nbsp;cumul&nbsp;function&nbsp;that&nbsp;determines&nbsp;whether&nbsp;max&nbsp;or&nbsp;min&nbsp;is<br>
used&nbsp;:&nbsp;respectively,&nbsp;<a href="#Alea">Alea</a>.pCumul&nbsp;or&nbsp;<a href="#Alea">Alea</a>.pInvCumul;<br>
the&nbsp;method&nbsp;uses&nbsp;an&nbsp;efficient&nbsp;algorithm&nbsp;(linear&nbsp;complexity),&nbsp;which&nbsp;is<br>
due&nbsp;to&nbsp;Nicky&nbsp;van&nbsp;Foreest;&nbsp;for&nbsp;explanations,&nbsp;see<br>
<a href="http://nicky.vanforeest.com/scheduling/cpm/stochasticMakespan.html">http://nicky.vanforeest.com/scheduling/cpm/stochasticMakespan.html</a></tt></dd></dl>

<dl><dt><a name="Alea-fromValFreqs"><strong>fromValFreqs</strong></a>(*valueFreqs)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;distribution<br>
for&nbsp;the&nbsp;given&nbsp;sequence&nbsp;of&nbsp;(val,freq)&nbsp;tuples,&nbsp;where&nbsp;freq&nbsp;is&nbsp;a&nbsp;natural&nbsp;number<br>
so&nbsp;that&nbsp;each&nbsp;value&nbsp;is&nbsp;taken&nbsp;with&nbsp;the&nbsp;given&nbsp;frequency&nbsp;(or&nbsp;sum&nbsp;of&nbsp;<br>
frequencies&nbsp;of&nbsp;that&nbsp;value&nbsp;if&nbsp;it&nbsp;occurs&nbsp;multiple&nbsp;times);<br>
the&nbsp;frequencies&nbsp;are&nbsp;reduced&nbsp;by&nbsp;dividing&nbsp;them&nbsp;by&nbsp;their&nbsp;GCD<br>
if&nbsp;the&nbsp;sequence&nbsp;is&nbsp;empty,&nbsp;then&nbsp;an&nbsp;exception&nbsp;is&nbsp;raised</tt></dd></dl>

<dl><dt><a name="Alea-fromValFreqsDict"><strong>fromValFreqsDict</strong></a>(probDict, reducing<font color="#909090">=True</font>)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;distribution<br>
for&nbsp;the&nbsp;given&nbsp;probDict&nbsp;dictionary&nbsp;of&nbsp;{val:prob},&nbsp;where&nbsp;prob&nbsp;is&nbsp;an&nbsp;integer&nbsp;number<br>
so&nbsp;that&nbsp;each&nbsp;value&nbsp;val&nbsp;has&nbsp;probability&nbsp;proportional&nbsp;to&nbsp;prob&nbsp;to&nbsp;occur<br>
any&nbsp;value&nbsp;with&nbsp;null&nbsp;probability&nbsp;is&nbsp;ignored&nbsp;(hence&nbsp;not&nbsp;stored)<br>
if&nbsp;reducing&nbsp;is&nbsp;True,&nbsp;then&nbsp;the&nbsp;probability&nbsp;weights&nbsp;are&nbsp;reduced&nbsp;to&nbsp;have&nbsp;a&nbsp;GCD&nbsp;=&nbsp;1<br>
if&nbsp;the&nbsp;sequence&nbsp;is&nbsp;empty,&nbsp;then&nbsp;an&nbsp;exception&nbsp;is&nbsp;raised</tt></dd></dl>

<dl><dt><a name="Alea-fromValFreqsDictGen"><strong>fromValFreqsDictGen</strong></a>(probDict)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;distribution<br>
for&nbsp;the&nbsp;given&nbsp;probDict&nbsp;dictionary&nbsp;of&nbsp;{val:prob},&nbsp;where&nbsp;prob&nbsp;is&nbsp;an&nbsp;integer&nbsp;number,<br>
a&nbsp;floating-point&nbsp;number&nbsp;or&nbsp;a&nbsp;fraction&nbsp;(Fraction&nbsp;or&nbsp;ProbFraction&nbsp;instance)<br>
so&nbsp;that&nbsp;each&nbsp;value&nbsp;val&nbsp;has&nbsp;probability&nbsp;proportional&nbsp;to&nbsp;prob&nbsp;to&nbsp;occur<br>
any&nbsp;value&nbsp;with&nbsp;null&nbsp;probability&nbsp;is&nbsp;ignored&nbsp;(hence&nbsp;not&nbsp;stored)<br>
if&nbsp;the&nbsp;sequence&nbsp;is&nbsp;empty,&nbsp;then&nbsp;an&nbsp;exception&nbsp;is&nbsp;raised</tt></dd></dl>

<dl><dt><a name="Alea-fromValFreqsNR"><strong>fromValFreqsNR</strong></a>(*valueFreqs)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;distribution<br>
for&nbsp;the&nbsp;given&nbsp;sequence&nbsp;of&nbsp;(val,freq)&nbsp;tuples,&nbsp;where&nbsp;freq&nbsp;is&nbsp;a&nbsp;natural&nbsp;number<br>
so&nbsp;that&nbsp;each&nbsp;value&nbsp;is&nbsp;taken&nbsp;with&nbsp;the&nbsp;given&nbsp;frequency&nbsp;(or&nbsp;sum&nbsp;of&nbsp;<br>
frequencies&nbsp;of&nbsp;that&nbsp;value&nbsp;if&nbsp;it&nbsp;occurs&nbsp;multiple&nbsp;times);<br>
if&nbsp;the&nbsp;sequence&nbsp;is&nbsp;empty,&nbsp;then&nbsp;an&nbsp;exception&nbsp;is&nbsp;raised</tt></dd></dl>

<dl><dt><a name="Alea-fromVals"><strong>fromVals</strong></a>(*values)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;distribution<br>
for&nbsp;the&nbsp;given&nbsp;sequence&nbsp;of&nbsp;values,&nbsp;so&nbsp;that&nbsp;each&nbsp;value&nbsp;occurrence&nbsp;is<br>
taken&nbsp;as&nbsp;equiprobable;<br>
if&nbsp;each&nbsp;value&nbsp;occurs&nbsp;exactly&nbsp;once,&nbsp;then&nbsp;the&nbsp;distribution&nbsp;is&nbsp;uniform,<br>
i.e.&nbsp;the&nbsp;probability&nbsp;of&nbsp;each&nbsp;value&nbsp;is&nbsp;equal&nbsp;to&nbsp;1&nbsp;/&nbsp;#values;<br>
if&nbsp;the&nbsp;sequence&nbsp;is&nbsp;empty,&nbsp;then&nbsp;an&nbsp;exception&nbsp;is&nbsp;raised</tt></dd></dl>

<dl><dt><a name="Alea-poisson"><strong>poisson</strong></a>(mean, precision)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;Poisson&nbsp;probability<br>
distribution&nbsp;having&nbsp;the&nbsp;given&nbsp;mean;&nbsp;the&nbsp;distribution&nbsp;is&nbsp;approximated&nbsp;by<br>
the&nbsp;finite&nbsp;set&nbsp;of&nbsp;values&nbsp;that&nbsp;have&nbsp;probability&nbsp;&gt;&nbsp;precision<br>
(i.e.&nbsp;low/high&nbsp;values&nbsp;with&nbsp;too&nbsp;small&nbsp;probabilities&nbsp;are&nbsp;dropped)</tt></dd></dl>

<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>indicatorMethodNames</strong> = ('mean', 'var', 'std', 'mode', 'entropy', 'information')</dl>

<hr>
Methods inherited from <a href="lea.html#Lea">lea.Lea</a>:<br>
<dl><dt><a name="Alea-__abs__"><strong>__abs__</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;applying&nbsp;the&nbsp;abs&nbsp;function&nbsp;on&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"abs(self)"</tt></dd></dl>

<dl><dt><a name="Alea-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;addition&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;with&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;+&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__and__"><strong>__and__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;locical&nbsp;AND&nbsp;between&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;and&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;&amp;&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__call__"><strong>__call__</strong></a>(self, *args)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
of&nbsp;values&nbsp;returned&nbsp;by&nbsp;invoking&nbsp;functions&nbsp;of&nbsp;current&nbsp;distribution&nbsp;on&nbsp;<br>
given&nbsp;arguments&nbsp;(assuming&nbsp;that&nbsp;the&nbsp;values&nbsp;of&nbsp;current&nbsp;distribution&nbsp;are<br>
functions);<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self(*args)"</tt></dd></dl>

<dl><dt><a name="Alea-__div__"><strong>__div__</strong></a> = __truediv__(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;division&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;by&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;/&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__divmod__"><strong>__divmod__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;applying&nbsp;the&nbsp;function&nbsp;divmod&nbsp;on&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;and&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"divmod(self,other)"</tt></dd></dl>

<dl><dt><a name="Alea-__eq__"><strong>__eq__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
that&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;are&nbsp;equal&nbsp;to&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;==&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__floordiv__"><strong>__floordiv__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;integer&nbsp;division&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;by&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;//&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__ge__"><strong>__ge__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
that&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;are&nbsp;greater&nbsp;than&nbsp;or&nbsp;equal&nbsp;to&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;&gt;=&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__getattribute__"><strong>__getattribute__</strong></a>(self, attrName)</dt><dd><tt>returns&nbsp;the&nbsp;attribute&nbsp;with&nbsp;the&nbsp;given&nbsp;name&nbsp;in&nbsp;the&nbsp;current&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance;<br>
if&nbsp;the&nbsp;attribute&nbsp;name&nbsp;is&nbsp;a&nbsp;distribution&nbsp;indicator,&nbsp;then&nbsp;the&nbsp;distribution<br>
is&nbsp;evaluated&nbsp;and&nbsp;the&nbsp;indicator&nbsp;method&nbsp;is&nbsp;called;&nbsp;<br>
if&nbsp;the&nbsp;attribute&nbsp;name&nbsp;is&nbsp;unknown&nbsp;as&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance's&nbsp;attribute,<br>
then&nbsp;returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;that&nbsp;shall&nbsp;retrieve&nbsp;the&nbsp;attibute&nbsp;in&nbsp;the<br>
values&nbsp;of&nbsp;current&nbsp;distribution;&nbsp;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self.<strong>attrName</strong>"<br>
WARNING:&nbsp;the&nbsp;following&nbsp;methods&nbsp;are&nbsp;called&nbsp;without&nbsp;parentheses:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;mean,&nbsp;var,&nbsp;std,&nbsp;mode,&nbsp;entropy,&nbsp;information<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;these&nbsp;are&nbsp;applicable&nbsp;on&nbsp;any&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;and&nbsp;these&nbsp;are&nbsp;documented&nbsp;in&nbsp;the&nbsp;<a href="#Alea">Alea</a>&nbsp;class</tt></dd></dl>

<dl><dt><a name="Alea-__getitem__"><strong>__getitem__</strong></a>(self, index)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
obtained&nbsp;by&nbsp;indexing&nbsp;or&nbsp;slicing&nbsp;each&nbsp;value&nbsp;with&nbsp;index<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self[index]"</tt></dd></dl>

<dl><dt><a name="Alea-__gt__"><strong>__gt__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
that&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;are&nbsp;greater&nbsp;than&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;&gt;&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__hash__"><strong>__hash__</strong></a>(self)</dt></dl>

<dl><dt><a name="Alea-__invert__"><strong>__invert__</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;locical&nbsp;NOT&nbsp;of&nbsp;the&nbsp;values&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"~self"</tt></dd></dl>

<dl><dt><a name="Alea-__iter__"><strong>__iter__</strong></a>(self)</dt><dd><tt>returns&nbsp;the&nbsp;iterator&nbsp;returned&nbsp;by&nbsp;genVP()<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"iter(self)",&nbsp;"tuple(self)",&nbsp;"list(self"&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;or&nbsp;on&nbsp;"for&nbsp;x&nbsp;in&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__le__"><strong>__le__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
that&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;are&nbsp;less&nbsp;than&nbsp;or&nbsp;equal&nbsp;to&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;&lt;=&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__lt__"><strong>__lt__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
that&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;are&nbsp;less&nbsp;than&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;&lt;&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__mod__"><strong>__mod__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;modulus&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;with&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;%&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__mul__"><strong>__mul__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;multiplication&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;by&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;*&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__ne__"><strong>__ne__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
that&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;are&nbsp;different&nbsp;from&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;!=&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__neg__"><strong>__neg__</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;negating&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"-self"</tt></dd></dl>

<dl><dt><a name="Alea-__nonzero__"><strong>__nonzero__</strong></a>(self)</dt><dd><tt>raises&nbsp;an&nbsp;exception&nbsp;telling&nbsp;that&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance&nbsp;cannot&nbsp;be&nbsp;evaluated&nbsp;as&nbsp;a&nbsp;boolean<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"bool(self)"</tt></dd></dl>

<dl><dt><a name="Alea-__or__"><strong>__or__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;locical&nbsp;OR&nbsp;between&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;and&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;|&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__pos__"><strong>__pos__</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;applying&nbsp;the&nbsp;unary&nbsp;positive&nbsp;operator&nbsp;on&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"+self"</tt></dd></dl>

<dl><dt><a name="Alea-__pow__"><strong>__pow__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;powering&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;with&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;**&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;addition&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;with&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"other&nbsp;+&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__rand__"><strong>__rand__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;locical&nbsp;AND&nbsp;between&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;and&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"other&nbsp;&amp;&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__rdiv__"><strong>__rdiv__</strong></a> = __rtruediv__(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;division&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;by&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"other&nbsp;/&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__rdivmod__"><strong>__rdivmod__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;applying&nbsp;the&nbsp;function&nbsp;divmod&nbsp;on&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;and&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"divmod(other,self)"</tt></dd></dl>

<dl><dt><a name="Alea-__repr__"><strong>__repr__</strong></a> = __str__(self)</dt><dd><tt>returns,&nbsp;after&nbsp;evaluation&nbsp;of&nbsp;the&nbsp;probability&nbsp;distribution&nbsp;self,&nbsp;a&nbsp;string<br>
representation&nbsp;of&nbsp;it;<br>
it&nbsp;contains&nbsp;one&nbsp;line&nbsp;per&nbsp;distinct&nbsp;value,&nbsp;separated&nbsp;by&nbsp;a&nbsp;newline&nbsp;character;<br>
each&nbsp;line&nbsp;contains&nbsp;the&nbsp;string&nbsp;representation&nbsp;of&nbsp;a&nbsp;value&nbsp;&nbsp;with&nbsp;its<br>
probability&nbsp;expressed&nbsp;as&nbsp;a&nbsp;rational&nbsp;number&nbsp;"n/d"&nbsp;or&nbsp;"0"&nbsp;or&nbsp;"1";<br>
if&nbsp;an&nbsp;order&nbsp;relationship&nbsp;is&nbsp;defined&nbsp;on&nbsp;values,&nbsp;then&nbsp;the&nbsp;values&nbsp;are&nbsp;sorted&nbsp;by&nbsp;<br>
increasing&nbsp;order;&nbsp;otherwise,&nbsp;an&nbsp;arbitrary&nbsp;order&nbsp;is&nbsp;used;<br>
called&nbsp;on&nbsp;evalution&nbsp;of&nbsp;"str(self)"&nbsp;and&nbsp;"repr(self)"</tt></dd></dl>

<dl><dt><a name="Alea-__rfloordiv__"><strong>__rfloordiv__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;integer&nbsp;division&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;by&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"other&nbsp;//&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__rmod__"><strong>__rmod__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;modulus&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;with&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"other&nbsp;%&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__rmul__"><strong>__rmul__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;multiplication&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;by&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"other&nbsp;*&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__ror__"><strong>__ror__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;locical&nbsp;OR&nbsp;between&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;and&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"other&nbsp;|&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__rpow__"><strong>__rpow__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;powering&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;with&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"other&nbsp;**&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__rsub__"><strong>__rsub__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;subtraction&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;from&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"other&nbsp;-&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__rtruediv__"><strong>__rtruediv__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;division&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;by&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"other&nbsp;/&nbsp;self"</tt></dd></dl>

<dl><dt><a name="Alea-__sub__"><strong>__sub__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;subtraction&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;other&nbsp;from&nbsp;the&nbsp;values&nbsp;of&nbsp;self;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;-&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__truediv__"><strong>__truediv__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;division&nbsp;of&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;by&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;/&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-__xor__"><strong>__xor__</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
resulting&nbsp;from&nbsp;the&nbsp;locical&nbsp;XOR&nbsp;between&nbsp;the&nbsp;values&nbsp;of&nbsp;self&nbsp;and&nbsp;the&nbsp;values&nbsp;of&nbsp;other;<br>
called&nbsp;on&nbsp;evaluation&nbsp;of&nbsp;"self&nbsp;^&nbsp;other"</tt></dd></dl>

<dl><dt><a name="Alea-asJoint"><strong>asJoint</strong></a>(self, *attrNames)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Olea&nbsp;instance&nbsp;representing&nbsp;a&nbsp;joint&nbsp;probability&nbsp;distribution<br>
from&nbsp;the&nbsp;current&nbsp;distribution&nbsp;supposed&nbsp;to&nbsp;have&nbsp;n-tuples&nbsp;as&nbsp;values,<br>
to&nbsp;be&nbsp;associated&nbsp;with&nbsp;the&nbsp;given&nbsp;n&nbsp;attribute&nbsp;names</tt></dd></dl>

<dl><dt><a name="Alea-cdf"><strong>cdf</strong></a>(self, val<font color="#909090">=None</font>)</dt><dd><tt>cumulative&nbsp;distribution&nbsp;function<br>
returns&nbsp;the&nbsp;probability&nbsp;that&nbsp;self's&nbsp;value&nbsp;is&nbsp;less&nbsp;or&nbsp;equal&nbsp;to&nbsp;the&nbsp;given&nbsp;value&nbsp;val,<br>
as&nbsp;a&nbsp;floating&nbsp;point&nbsp;number&nbsp;from&nbsp;0.0&nbsp;to&nbsp;1.0<br>
if&nbsp;val&nbsp;is&nbsp;None,&nbsp;then&nbsp;a&nbsp;tuple&nbsp;is&nbsp;returned&nbsp;with&nbsp;the&nbsp;probabilities&nbsp;of&nbsp;each&nbsp;value,<br>
in&nbsp;the&nbsp;same&nbsp;order&nbsp;as&nbsp;defined&nbsp;on&nbsp;values&nbsp;(call&nbsp;vals&nbsp;method&nbsp;to&nbsp;get&nbsp;this&nbsp;<br>
ordered&nbsp;sequence);&nbsp;the&nbsp;last&nbsp;probability&nbsp;is&nbsp;always&nbsp;1.0</tt></dd></dl>

<dl><dt><a name="Alea-clone"><strong>clone</strong></a>(self, cloneTable<font color="#909090">=None</font>)</dt><dd><tt>returns&nbsp;a&nbsp;deep&nbsp;copy&nbsp;of&nbsp;current&nbsp;<a href="lea.html#Lea">Lea</a>,&nbsp;without&nbsp;any&nbsp;value&nbsp;binding;<br>
if&nbsp;the&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;tree&nbsp;contains&nbsp;multiple&nbsp;references&nbsp;to&nbsp;the&nbsp;same&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance,<br>
then&nbsp;it&nbsp;is&nbsp;cloned&nbsp;only&nbsp;once&nbsp;and&nbsp;the&nbsp;references&nbsp;are&nbsp;copied&nbsp;in&nbsp;the&nbsp;cloned&nbsp;tree<br>
(the&nbsp;cloneTable&nbsp;dictionary&nbsp;serves&nbsp;this&nbsp;purpose);<br>
the&nbsp;method&nbsp;calls&nbsp;the&nbsp;_clone()&nbsp;method&nbsp;implemented&nbsp;in&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;subclasses</tt></dd></dl>

<dl><dt><a name="Alea-cprod"><strong>cprod</strong></a>(self, *args)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Clea&nbsp;instance,&nbsp;representing&nbsp;the&nbsp;cartesian&nbsp;product&nbsp;of&nbsp;all<br>
arguments&nbsp;(coerced&nbsp;to&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instances),&nbsp;including&nbsp;self&nbsp;as&nbsp;first&nbsp;argument</tt></dd></dl>

<dl><dt><a name="Alea-cprodTimes"><strong>cprodTimes</strong></a>(self, nTimes)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Plea&nbsp;instance,&nbsp;representing&nbsp;the&nbsp;cartesian&nbsp;product&nbsp;of&nbsp;self<br>
with&nbsp;itself,&nbsp;iterated&nbsp;nTimes</tt></dd></dl>

<dl><dt><a name="Alea-draw"><strong>draw</strong></a>(self, nbValues)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Dlea&nbsp;instance&nbsp;representing&nbsp;a&nbsp;probability&nbsp;distribution&nbsp;of&nbsp;the<br>
sequences&nbsp;of&nbsp;values&nbsp;obtained&nbsp;by&nbsp;the&nbsp;given&nbsp;number&nbsp;of&nbsp;draws&nbsp;without<br>
replacement&nbsp;from&nbsp;the&nbsp;current&nbsp;distribution</tt></dd></dl>

<dl><dt><a name="Alea-equiv"><strong>equiv</strong></a>(self, other)</dt><dd><tt>returns&nbsp;True&nbsp;iff&nbsp;self&nbsp;and&nbsp;other&nbsp;represent&nbsp;the&nbsp;same&nbsp;probability&nbsp;distribution,<br>
i.e.&nbsp;they&nbsp;have&nbsp;the&nbsp;same&nbsp;probability&nbsp;for&nbsp;each&nbsp;of&nbsp;their&nbsp;value<br>
returns&nbsp;False&nbsp;otherwise</tt></dd></dl>

<dl><dt><a name="Alea-flat"><strong>flat</strong></a>(self)</dt><dd><tt>assuming&nbsp;that&nbsp;self's&nbsp;values&nbsp;are&nbsp;themselves&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instances,<br>
returns&nbsp;a&nbsp;new&nbsp;Rlea&nbsp;instance&nbsp;representing&nbsp;a&nbsp;probability&nbsp;distribution&nbsp;of<br>
inner&nbsp;values&nbsp;of&nbsp;these&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instances</tt></dd></dl>

<dl><dt><a name="Alea-genVPs"><strong>genVPs</strong></a>(self)</dt><dd><tt>generates&nbsp;tuple&nbsp;(v,p)&nbsp;where&nbsp;v&nbsp;is&nbsp;a&nbsp;value&nbsp;of&nbsp;the&nbsp;current&nbsp;probability&nbsp;distribution<br>
and&nbsp;p&nbsp;is&nbsp;the&nbsp;associated&nbsp;probability&nbsp;weight&nbsp;(integer&nbsp;&gt;&nbsp;0);<br>
before&nbsp;yielding&nbsp;a&nbsp;value&nbsp;v,&nbsp;this&nbsp;value&nbsp;is&nbsp;bound&nbsp;to&nbsp;the&nbsp;current&nbsp;instance;<br>
then,&nbsp;if&nbsp;the&nbsp;current&nbsp;calculation&nbsp;requires&nbsp;to&nbsp;get&nbsp;again&nbsp;values&nbsp;on&nbsp;the&nbsp;current<br>
instance,&nbsp;then&nbsp;the&nbsp;bound&nbsp;value&nbsp;is&nbsp;yielded&nbsp;with&nbsp;probability&nbsp;1;<br>
the&nbsp;instance&nbsp;is&nbsp;rebound&nbsp;to&nbsp;a&nbsp;new&nbsp;value&nbsp;at&nbsp;each&nbsp;iteration,&nbsp;as&nbsp;soon&nbsp;as&nbsp;the&nbsp;execution<br>
is&nbsp;resumed&nbsp;after&nbsp;the&nbsp;yield;<br>
it&nbsp;is&nbsp;unbound&nbsp;at&nbsp;the&nbsp;end;<br>
the&nbsp;method&nbsp;calls&nbsp;the&nbsp;_genVPs&nbsp;method&nbsp;implemented&nbsp;in&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;subclasses;</tt></dd></dl>

<dl><dt><a name="Alea-getAlea"><strong>getAlea</strong></a>(self)</dt><dd><tt>returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;the&nbsp;distribution&nbsp;after&nbsp;it&nbsp;has&nbsp;been&nbsp;evaluated;<br>
Note&nbsp;:&nbsp;the&nbsp;returned&nbsp;value&nbsp;is&nbsp;cached&nbsp;(the&nbsp;evaluation&nbsp;occurs&nbsp;only&nbsp;for&nbsp;the&nbsp;first&nbsp;call,<br>
for&nbsp;successive&nbsp;calls,&nbsp;a&nbsp;cached&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;is&nbsp;returned,&nbsp;which&nbsp;is&nbsp;faster)</tt></dd></dl>

<dl><dt><a name="Alea-given"><strong>given</strong></a>(self, info)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Ilea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;current&nbsp;distribution<br>
updated&nbsp;with&nbsp;the&nbsp;given&nbsp;info,&nbsp;which&nbsp;is&nbsp;either&nbsp;a&nbsp;boolean&nbsp;or&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance<br>
with&nbsp;boolean&nbsp;values;&nbsp;the&nbsp;values&nbsp;present&nbsp;in&nbsp;the&nbsp;returned&nbsp;distribution&nbsp;<br>
are&nbsp;those&nbsp;and&nbsp;only&nbsp;those&nbsp;compatible&nbsp;with&nbsp;the&nbsp;given&nbsp;info<br>
The&nbsp;resulting&nbsp;(value,probability)&nbsp;pairs&nbsp;are&nbsp;calculated&nbsp;<br>
when&nbsp;the&nbsp;returned&nbsp;Ilea&nbsp;instance&nbsp;is&nbsp;evaluated;&nbsp;if&nbsp;no&nbsp;value&nbsp;is&nbsp;found,<br>
then&nbsp;an&nbsp;exception&nbsp;is&nbsp;raised</tt></dd></dl>

<dl><dt><a name="Alea-id"><strong>id</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;unique&nbsp;id,&nbsp;containing&nbsp;the&nbsp;concrete&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;class&nbsp;name&nbsp;as&nbsp;prefix</tt></dd></dl>

<dl><dt><a name="Alea-information"><strong>information</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;float&nbsp;number&nbsp;representing&nbsp;the&nbsp;information&nbsp;of&nbsp;self&nbsp;being&nbsp;true,<br>
expressed&nbsp;in&nbsp;bits&nbsp;(assuming&nbsp;that&nbsp;self&nbsp;is&nbsp;a&nbsp;boolean&nbsp;distribution)<br>
raises&nbsp;an&nbsp;exception&nbsp;if&nbsp;self&nbsp;is&nbsp;certainly&nbsp;false</tt></dd></dl>

<dl><dt><a name="Alea-informationOf"><strong>informationOf</strong></a>(self, val)</dt><dd><tt>returns&nbsp;a&nbsp;float&nbsp;number&nbsp;representing&nbsp;the&nbsp;information&nbsp;of&nbsp;given&nbsp;val,<br>
expressed&nbsp;in&nbsp;bits<br>
raises&nbsp;an&nbsp;exception&nbsp;if&nbsp;given&nbsp;val&nbsp;is&nbsp;impossible</tt></dd></dl>

<dl><dt><a name="Alea-isAnyOf"><strong>isAnyOf</strong></a>(self, *values)</dt><dd><tt>returns&nbsp;a&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
indicating&nbsp;the&nbsp;probability&nbsp;that&nbsp;a&nbsp;value&nbsp;is&nbsp;any&nbsp;of&nbsp;the&nbsp;values&nbsp;passed&nbsp;as&nbsp;arguments</tt></dd></dl>

<dl><dt><a name="Alea-isFeasible"><strong>isFeasible</strong></a>(self)</dt><dd><tt>returns&nbsp;True&nbsp;iff&nbsp;the&nbsp;value&nbsp;True&nbsp;has&nbsp;a&nbsp;non-null&nbsp;probability;<br>
returns&nbsp;False&nbsp;otherwise;<br>
raises&nbsp;exception&nbsp;if&nbsp;some&nbsp;value&nbsp;are&nbsp;not&nbsp;booleans</tt></dd></dl>

<dl><dt><a name="Alea-isNoneOf"><strong>isNoneOf</strong></a>(self, *values)</dt><dd><tt>returns&nbsp;a&nbsp;boolean&nbsp;probability&nbsp;distribution<br>
indicating&nbsp;the&nbsp;probability&nbsp;that&nbsp;a&nbsp;value&nbsp;is&nbsp;none&nbsp;of&nbsp;the&nbsp;given&nbsp;values&nbsp;passed&nbsp;as&nbsp;arguments</tt></dd></dl>

<dl><dt><a name="Alea-isTrue"><strong>isTrue</strong></a>(self)</dt><dd><tt>returns&nbsp;True&nbsp;iff&nbsp;the&nbsp;value&nbsp;True&nbsp;has&nbsp;probability&nbsp;1;<br>
returns&nbsp;False&nbsp;otherwise</tt></dd></dl>

<dl><dt><a name="Alea-map"><strong>map</strong></a>(self, f, args<font color="#909090">=()</font>)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;distribution&nbsp;obtained<br>
by&nbsp;applying&nbsp;the&nbsp;given&nbsp;function&nbsp;f,&nbsp;taking&nbsp;values&nbsp;of&nbsp;self&nbsp;distribution<br>
as&nbsp;first&nbsp;argument&nbsp;and&nbsp;given&nbsp;args&nbsp;tuple&nbsp;as&nbsp;following&nbsp;arguments&nbsp;(expanded);<br>
requires&nbsp;that&nbsp;f&nbsp;is&nbsp;a&nbsp;n-ary&nbsp;function&nbsp;with&nbsp;1&nbsp;&lt;=&nbsp;n&nbsp;=&nbsp;len(args)+1&nbsp;<br>
note:&nbsp;f&nbsp;can&nbsp;be&nbsp;also&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance,&nbsp;with&nbsp;functions&nbsp;as&nbsp;values</tt></dd></dl>

<dl><dt><a name="Alea-mapSeq"><strong>mapSeq</strong></a>(self, f, args<font color="#909090">=()</font>)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Flea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;distribution&nbsp;obtained<br>
by&nbsp;applying&nbsp;the&nbsp;given&nbsp;function&nbsp;f&nbsp;on&nbsp;each&nbsp;element&nbsp;of&nbsp;each&nbsp;value<br>
of&nbsp;self&nbsp;distribution;&nbsp;if&nbsp;args&nbsp;is&nbsp;not&nbsp;empty,&nbsp;then&nbsp;it&nbsp;is&nbsp;expanded<br>
and&nbsp;added&nbsp;as&nbsp;f&nbsp;arguments<br>
requires&nbsp;that&nbsp;f&nbsp;is&nbsp;a&nbsp;n-ary&nbsp;function&nbsp;with&nbsp;1&nbsp;&lt;=&nbsp;n&nbsp;=&nbsp;len(args)+1&nbsp;<br>
requires&nbsp;that&nbsp;self's&nbsp;values&nbsp;are&nbsp;sequences<br>
returned&nbsp;distribution&nbsp;values&nbsp;are&nbsp;tuples<br>
note:&nbsp;f&nbsp;can&nbsp;be&nbsp;also&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance,&nbsp;with&nbsp;functions&nbsp;as&nbsp;values</tt></dd></dl>

<dl><dt><a name="Alea-merge"><strong>merge</strong></a>(self, *leaArgs)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Mlea&nbsp;instance,&nbsp;representing&nbsp;the&nbsp;merge&nbsp;of&nbsp;given&nbsp;leaArgs,&nbsp;i.e.<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;P(v)&nbsp;=&nbsp;(P1(v)&nbsp;+&nbsp;...&nbsp;+&nbsp;Pn(v))&nbsp;/&nbsp;n<br>
where&nbsp;P(v)&nbsp;&nbsp;is&nbsp;the&nbsp;probability&nbsp;of&nbsp;value&nbsp;v&nbsp;in&nbsp;the&nbsp;merge&nbsp;result&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Pi(v)&nbsp;is&nbsp;the&nbsp;probability&nbsp;of&nbsp;value&nbsp;v&nbsp;in&nbsp;leaArgs[i]</tt></dd></dl>

<dl><dt><a name="Alea-mutualInformation"><strong>mutualInformation</strong></a>(self, other)</dt><dd><tt>returns&nbsp;a&nbsp;float&nbsp;number&nbsp;representing&nbsp;the&nbsp;mutual&nbsp;information&nbsp;between&nbsp;self&nbsp;and&nbsp;other,<br>
expressed&nbsp;in&nbsp;bits</tt></dd></dl>

<dl><dt><a name="Alea-p"><strong>p</strong></a>(self, val<font color="#909090">=None</font>)</dt><dd><tt>returns&nbsp;a&nbsp;ProbFraction&nbsp;instance&nbsp;representing&nbsp;the&nbsp;probability&nbsp;of&nbsp;given&nbsp;value&nbsp;val,<br>
from&nbsp;0/1&nbsp;to&nbsp;1/1<br>
if&nbsp;val&nbsp;is&nbsp;None,&nbsp;then&nbsp;a&nbsp;tuple&nbsp;is&nbsp;returned&nbsp;with&nbsp;the&nbsp;probabilities&nbsp;of&nbsp;each&nbsp;value,<br>
in&nbsp;the&nbsp;same&nbsp;order&nbsp;as&nbsp;defined&nbsp;on&nbsp;values&nbsp;(call&nbsp;vals&nbsp;method&nbsp;to&nbsp;get&nbsp;this&nbsp;<br>
ordered&nbsp;sequence)</tt></dd></dl>

<dl><dt><a name="Alea-pmf"><strong>pmf</strong></a>(self, val<font color="#909090">=None</font>)</dt><dd><tt>probability&nbsp;mass&nbsp;function<br>
returns&nbsp;the&nbsp;probability&nbsp;of&nbsp;the&nbsp;given&nbsp;value&nbsp;val,&nbsp;as&nbsp;a&nbsp;floating&nbsp;point&nbsp;number<br>
from&nbsp;0.0&nbsp;to&nbsp;1.0<br>
if&nbsp;val&nbsp;is&nbsp;None,&nbsp;then&nbsp;a&nbsp;tuple&nbsp;is&nbsp;returned&nbsp;with&nbsp;the&nbsp;probabilities&nbsp;of&nbsp;each&nbsp;value,<br>
in&nbsp;the&nbsp;same&nbsp;order&nbsp;as&nbsp;defined&nbsp;on&nbsp;values&nbsp;(call&nbsp;vals&nbsp;method&nbsp;to&nbsp;get&nbsp;this&nbsp;<br>
ordered&nbsp;sequence)</tt></dd></dl>

<dl><dt><a name="Alea-ps"><strong>ps</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;tuple&nbsp;with&nbsp;probability&nbsp;weights&nbsp;(integer&nbsp;&gt;&nbsp;0)&nbsp;of&nbsp;self<br>
the&nbsp;sequence&nbsp;follows&nbsp;the&nbsp;increasing&nbsp;order&nbsp;defined&nbsp;on&nbsp;values<br>
if&nbsp;order&nbsp;is&nbsp;undefined&nbsp;(e.g.&nbsp;complex&nbsp;numbers),&nbsp;then&nbsp;the&nbsp;order&nbsp;is<br>
arbitrary&nbsp;but&nbsp;fixed&nbsp;from&nbsp;call&nbsp;to&nbsp;call</tt></dd></dl>

<dl><dt><a name="Alea-random"><strong>random</strong></a>(self, n<font color="#909090">=None</font>)</dt><dd><tt>evaluates&nbsp;the&nbsp;distribution,&nbsp;then,&nbsp;<br>
if&nbsp;n&nbsp;is&nbsp;None,&nbsp;returns&nbsp;a&nbsp;random&nbsp;value&nbsp;with&nbsp;the&nbsp;probability&nbsp;given&nbsp;by&nbsp;the&nbsp;distribution<br>
otherwise,&nbsp;returns&nbsp;a&nbsp;tuple&nbsp;of&nbsp;n&nbsp;such&nbsp;random&nbsp;values</tt></dd></dl>

<dl><dt><a name="Alea-reset"><strong>reset</strong></a>(self)</dt><dd><tt>removes&nbsp;current&nbsp;value&nbsp;binding&nbsp;(to&nbsp;be&nbsp;use&nbsp;only&nbsp;in&nbsp;case&nbsp;of&nbsp;brutal&nbsp;halt&nbsp;of&nbsp;<a href="#Alea-genVPs">genVPs</a>());<br>
this&nbsp;calls&nbsp;_getLeaChildren()&nbsp;method&nbsp;implemented&nbsp;in&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;subclasses</tt></dd></dl>

<dl><dt><a name="Alea-revisedWithCPT"><strong>revisedWithCPT</strong></a>(self, *clauses)</dt><dd><tt>returns&nbsp;an&nbsp;instance&nbsp;of&nbsp;Blea&nbsp;representing&nbsp;the&nbsp;conditional&nbsp;probability&nbsp;table<br>
(e.g.&nbsp;a&nbsp;node&nbsp;in&nbsp;a&nbsp;Bayes&nbsp;network)&nbsp;from&nbsp;the&nbsp;given&nbsp;clauses;<br>
each&nbsp;clause&nbsp;is&nbsp;a&nbsp;tuple&nbsp;(condition,result)<br>
where&nbsp;condition&nbsp;is&nbsp;a&nbsp;boolean&nbsp;or&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;boolean&nbsp;distribution<br>
&nbsp;&nbsp;and&nbsp;result&nbsp;is&nbsp;a&nbsp;value&nbsp;or&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;distribution&nbsp;representing&nbsp;the&nbsp;result<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;assuming&nbsp;that&nbsp;condition&nbsp;is&nbsp;true<br>
the&nbsp;conditions&nbsp;from&nbsp;all&nbsp;clauses&nbsp;shall&nbsp;be&nbsp;mutually&nbsp;exclusive<br>
no&nbsp;clause&nbsp;can&nbsp;contain&nbsp;None&nbsp;as&nbsp;condition<br>
the&nbsp;'else'&nbsp;clause&nbsp;is&nbsp;calculated&nbsp;so&nbsp;that&nbsp;the&nbsp;returned&nbsp;Blea&nbsp;if&nbsp;no&nbsp;condition&nbsp;is&nbsp;given&nbsp;<br>
is&nbsp;self</tt></dd></dl>

<dl><dt><a name="Alea-support"><strong>support</strong></a>(self)</dt><dd><tt>same&nbsp;as&nbsp;vals&nbsp;method</tt></dd></dl>

<dl><dt><a name="Alea-times"><strong>times</strong></a>(self, n, op<font color="#909090">=&lt;built-in function add&gt;</font>)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Tlea&nbsp;instance&nbsp;representing&nbsp;the&nbsp;current&nbsp;distribution<br>
operated&nbsp;n&nbsp;times&nbsp;with&nbsp;itself,&nbsp;through&nbsp;the&nbsp;given&nbsp;binary&nbsp;operator</tt></dd></dl>

<dl><dt><a name="Alea-timesTuple"><strong>timesTuple</strong></a>(self, n)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Tlea&nbsp;instance&nbsp;with&nbsp;tuples&nbsp;of&nbsp;length&nbsp;n,&nbsp;containing<br>
the&nbsp;cartesian&nbsp;product&nbsp;of&nbsp;self&nbsp;with&nbsp;itslef&nbsp;repeated&nbsp;n&nbsp;times</tt></dd></dl>

<dl><dt><a name="Alea-vals"><strong>vals</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;tuple&nbsp;with&nbsp;values&nbsp;of&nbsp;self<br>
the&nbsp;sequence&nbsp;follows&nbsp;the&nbsp;increasing&nbsp;order&nbsp;defined&nbsp;on&nbsp;values<br>
if&nbsp;order&nbsp;is&nbsp;undefined&nbsp;(e.g.&nbsp;complex&nbsp;numbers),&nbsp;then&nbsp;the&nbsp;order&nbsp;is<br>
arbitrary&nbsp;but&nbsp;fixed&nbsp;from&nbsp;call&nbsp;to&nbsp;call</tt></dd></dl>

<dl><dt><a name="Alea-vps"><strong>vps</strong></a>(self)</dt><dd><tt>returns&nbsp;a&nbsp;tuple&nbsp;with&nbsp;tuples&nbsp;(v,p)&nbsp;where&nbsp;v&nbsp;is&nbsp;a&nbsp;value&nbsp;of&nbsp;self<br>
and&nbsp;p&nbsp;is&nbsp;the&nbsp;associated&nbsp;probability&nbsp;weight&nbsp;(integer&nbsp;&gt;&nbsp;0);<br>
the&nbsp;sequence&nbsp;follows&nbsp;the&nbsp;order&nbsp;defined&nbsp;on&nbsp;values</tt></dd></dl>

<dl><dt><a name="Alea-withCondProb"><strong>withCondProb</strong></a>(self, condLea, givenCondLea, pNum, pDen)</dt><dd><tt>[DEPRECATED:&nbsp;use&nbsp;<a href="lea.html#Lea">Lea</a>.revisedWithCPT&nbsp;instead]<br>
returns&nbsp;a&nbsp;new&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;from&nbsp;current&nbsp;distribution,<br>
such&nbsp;that&nbsp;pNum/pDen&nbsp;is&nbsp;the&nbsp;probability&nbsp;that&nbsp;condLea&nbsp;is&nbsp;true<br>
given&nbsp;that&nbsp;givenCondLea&nbsp;is&nbsp;True,&nbsp;under&nbsp;the&nbsp;constraint&nbsp;that<br>
the&nbsp;returned&nbsp;distribution&nbsp;keeps&nbsp;prior&nbsp;probabilities&nbsp;of&nbsp;condLea<br>
and&nbsp;givenCondLea&nbsp;unchanged</tt></dd></dl>

<dl><dt><a name="Alea-withProb"><strong>withProb</strong></a>(self, condLea, pNum, pDen<font color="#909090">=None</font>)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;from&nbsp;current&nbsp;distribution,<br>
such&nbsp;that&nbsp;pNum/pDen&nbsp;is&nbsp;the&nbsp;probability&nbsp;that&nbsp;condLea&nbsp;is&nbsp;true<br>
if&nbsp;pDen&nbsp;is&nbsp;None,&nbsp;then&nbsp;pNum&nbsp;expresses&nbsp;the&nbsp;probability&nbsp;as&nbsp;a&nbsp;Fraction</tt></dd></dl>

<hr>
Static methods inherited from <a href="lea.html#Lea">lea.Lea</a>:<br>
<dl><dt><a name="Alea-bernoulli"><strong>bernoulli</strong></a>(pNum, pDen<font color="#909090">=None</font>)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;bernoulli<br>
distribution&nbsp;giving&nbsp;1&nbsp;with&nbsp;probability&nbsp;pNum/pDen&nbsp;and&nbsp;0&nbsp;with<br>
complementary&nbsp;probability;<br>
if&nbsp;pDen&nbsp;is&nbsp;None,&nbsp;then&nbsp;pNum&nbsp;expresses&nbsp;the&nbsp;probability&nbsp;as&nbsp;a&nbsp;Fraction</tt></dd></dl>

<dl><dt><a name="Alea-binom"><strong>binom</strong></a>(n, pNum, pDen<font color="#909090">=None</font>)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;binomial<br>
distribution&nbsp;giving&nbsp;the&nbsp;number&nbsp;of&nbsp;successes&nbsp;among&nbsp;a&nbsp;number&nbsp;n&nbsp;of&nbsp;<br>
independent&nbsp;experiments,&nbsp;each&nbsp;having&nbsp;probability&nbsp;pNum/pDen&nbsp;of&nbsp;success;&nbsp;&nbsp;<br>
if&nbsp;pDen&nbsp;is&nbsp;None,&nbsp;then&nbsp;pNum&nbsp;expresses&nbsp;the&nbsp;probability&nbsp;as&nbsp;a&nbsp;Fraction</tt></dd></dl>

<dl><dt><a name="Alea-boolProb"><strong>boolProb</strong></a>(pNum, pDen<font color="#909090">=None</font>)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;boolean<br>
distribution&nbsp;such&nbsp;that&nbsp;probability&nbsp;of&nbsp;True&nbsp;is&nbsp;pNum/pDen<br>
if&nbsp;pDen&nbsp;is&nbsp;None,&nbsp;then&nbsp;pNum&nbsp;expresses&nbsp;the&nbsp;probability&nbsp;as&nbsp;a&nbsp;Fraction</tt></dd></dl>

<dl><dt><a name="Alea-buildCPT"><strong>buildCPT</strong></a>(*clauses, **kwargs)</dt><dd><tt>returns&nbsp;an&nbsp;instance&nbsp;of&nbsp;Blea&nbsp;representing&nbsp;the&nbsp;conditional&nbsp;probability&nbsp;table<br>
(e.g.&nbsp;a&nbsp;node&nbsp;in&nbsp;a&nbsp;Bayes&nbsp;network)&nbsp;from&nbsp;the&nbsp;given&nbsp;clauses;<br>
each&nbsp;clause&nbsp;is&nbsp;a&nbsp;tuple&nbsp;(condition,result)<br>
where&nbsp;condition&nbsp;is&nbsp;a&nbsp;boolean&nbsp;or&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;boolean&nbsp;distribution<br>
&nbsp;&nbsp;and&nbsp;result&nbsp;is&nbsp;a&nbsp;value&nbsp;or&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;distribution&nbsp;representing&nbsp;the&nbsp;result<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;assuming&nbsp;that&nbsp;condition&nbsp;is&nbsp;true<br>
the&nbsp;conditions&nbsp;from&nbsp;all&nbsp;clauses&nbsp;shall&nbsp;be&nbsp;mutually&nbsp;exclusive<br>
if&nbsp;a&nbsp;clause&nbsp;contains&nbsp;None&nbsp;as&nbsp;condition,&nbsp;then&nbsp;it&nbsp;is&nbsp;considered&nbsp;as&nbsp;a&nbsp;'else'<br>
condition<br>
if&nbsp;a&nbsp;priorLea&nbsp;argument&nbsp;is&nbsp;specified,&nbsp;then&nbsp;the&nbsp;'else'&nbsp;clause&nbsp;is&nbsp;calculated<br>
so&nbsp;that&nbsp;the&nbsp;returned&nbsp;Blea&nbsp;if&nbsp;no&nbsp;condition&nbsp;is&nbsp;given&nbsp;is&nbsp;priorLea&nbsp;;&nbsp;it&nbsp;is&nbsp;an&nbsp;<br>
error&nbsp;to&nbsp;specify&nbsp;a&nbsp;'else'&nbsp;clause&nbsp;if&nbsp;priorLea&nbsp;argument&nbsp;is&nbsp;specified</tt></dd></dl>

<dl><dt><a name="Alea-buildCPTFromDict"><strong>buildCPTFromDict</strong></a>(aCPTDict, priorLea<font color="#909090">=None</font>)</dt><dd><tt>same&nbsp;as&nbsp;buildCPT,&nbsp;with&nbsp;clauses&nbsp;specified&nbsp;in&nbsp;the&nbsp;aCPTDict&nbsp;dictionary<br>
{condition:result}</tt></dd></dl>

<dl><dt><a name="Alea-coerce"><strong>coerce</strong></a>(value)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance&nbsp;corresponding&nbsp;the&nbsp;given&nbsp;value:<br>
if&nbsp;the&nbsp;value&nbsp;is&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance,&nbsp;then&nbsp;it&nbsp;is&nbsp;returned<br>
otherwise,&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;is&nbsp;returned,&nbsp;with&nbsp;given&nbsp;value<br>
as&nbsp;unique&nbsp;(certain)&nbsp;value</tt></dd></dl>

<dl><dt><a name="Alea-fastMax"><strong>fastMax</strong></a>(*args)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;giving&nbsp;the&nbsp;probabilities&nbsp;to&nbsp;have&nbsp;the&nbsp;maximum<br>
value&nbsp;of&nbsp;each&nbsp;combination&nbsp;of&nbsp;the&nbsp;given&nbsp;args;<br>
if&nbsp;some&nbsp;elements&nbsp;of&nbsp;args&nbsp;are&nbsp;not&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance,&nbsp;then&nbsp;these&nbsp;are&nbsp;coerced<br>
to&nbsp;an&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance&nbsp;with&nbsp;probability&nbsp;1;<br>
the&nbsp;method&nbsp;uses&nbsp;an&nbsp;efficient&nbsp;algorithm&nbsp;(linear&nbsp;complexity),&nbsp;which&nbsp;is<br>
due&nbsp;to&nbsp;Nicky&nbsp;van&nbsp;Foreest;&nbsp;for&nbsp;explanations,&nbsp;see<br>
<a href="http://nicky.vanforeest.com/scheduling/cpm/stochasticMakespan.html">http://nicky.vanforeest.com/scheduling/cpm/stochasticMakespan.html</a><br>
Note:&nbsp;unlike&nbsp;most&nbsp;of&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;methods,&nbsp;the&nbsp;distribution&nbsp;returned&nbsp;by&nbsp;<a href="lea.html#Lea">Lea</a>.fastMax<br>
loses&nbsp;any&nbsp;dependency&nbsp;with&nbsp;given&nbsp;args;&nbsp;this&nbsp;could&nbsp;be&nbsp;important&nbsp;if&nbsp;some&nbsp;args<br>
appear&nbsp;in&nbsp;the&nbsp;same&nbsp;expression&nbsp;as&nbsp;<a href="lea.html#Lea">Lea</a>.<a href="#Alea-max">max</a>(...)&nbsp;but&nbsp;outside&nbsp;it,&nbsp;e.g.<br>
conditional&nbsp;probability&nbsp;expressions;&nbsp;this&nbsp;limitation&nbsp;can&nbsp;be&nbsp;avoided&nbsp;by<br>
using&nbsp;the&nbsp;<a href="lea.html#Lea">Lea</a>.max&nbsp;method;&nbsp;however,&nbsp;this&nbsp;last&nbsp;method&nbsp;can&nbsp;be<br>
prohibitively&nbsp;slower&nbsp;(exponential&nbsp;complexity)</tt></dd></dl>

<dl><dt><a name="Alea-fastMin"><strong>fastMin</strong></a>(*args)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;giving&nbsp;the&nbsp;probabilities&nbsp;to&nbsp;have&nbsp;the&nbsp;minimum<br>
value&nbsp;of&nbsp;each&nbsp;combination&nbsp;of&nbsp;the&nbsp;given&nbsp;args;<br>
if&nbsp;some&nbsp;elements&nbsp;of&nbsp;args&nbsp;are&nbsp;not&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instances,&nbsp;then&nbsp;these&nbsp;are&nbsp;coerced<br>
to&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;with&nbsp;probability&nbsp;1;<br>
the&nbsp;method&nbsp;uses&nbsp;an&nbsp;efficient&nbsp;algorithm&nbsp;(linear&nbsp;complexity),&nbsp;which&nbsp;is<br>
due&nbsp;to&nbsp;Nicky&nbsp;van&nbsp;Foreest;&nbsp;for&nbsp;explanations,&nbsp;see<br>
<a href="http://nicky.vanforeest.com/scheduling/cpm/stochasticMakespan.html">http://nicky.vanforeest.com/scheduling/cpm/stochasticMakespan.html</a><br>
Note:&nbsp;unlike&nbsp;most&nbsp;of&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;methods,&nbsp;the&nbsp;distribution&nbsp;returned&nbsp;by&nbsp;<a href="lea.html#Lea">Lea</a>.fastMin<br>
loses&nbsp;any&nbsp;dependency&nbsp;with&nbsp;given&nbsp;args;&nbsp;this&nbsp;could&nbsp;be&nbsp;important&nbsp;if&nbsp;some&nbsp;args<br>
appear&nbsp;in&nbsp;the&nbsp;same&nbsp;expression&nbsp;as&nbsp;<a href="lea.html#Lea">Lea</a>.<a href="#Alea-min">min</a>(...)&nbsp;but&nbsp;outside&nbsp;it,&nbsp;e.g.<br>
conditional&nbsp;probability&nbsp;expressions;&nbsp;this&nbsp;limitation&nbsp;can&nbsp;be&nbsp;avoided&nbsp;by<br>
using&nbsp;the&nbsp;<a href="lea.html#Lea">Lea</a>.min&nbsp;method;&nbsp;however,&nbsp;this&nbsp;last&nbsp;method&nbsp;can&nbsp;be&nbsp;prohibitively<br>
slower&nbsp;(exponential&nbsp;complexity)</tt></dd></dl>

<dl><dt><a name="Alea-fromSeq"><strong>fromSeq</strong></a>(sequence)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;distribution<br>
for&nbsp;the&nbsp;given&nbsp;sequence&nbsp;of&nbsp;values&nbsp;(e.g.&nbsp;a&nbsp;list,&nbsp;tuple,&nbsp;iterator,...),<br>
so&nbsp;that&nbsp;each&nbsp;value&nbsp;occurrence&nbsp;is&nbsp;taken&nbsp;as&nbsp;equiprobable;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
if&nbsp;each&nbsp;value&nbsp;occurs&nbsp;exactly&nbsp;once,&nbsp;then&nbsp;the&nbsp;distribution&nbsp;is&nbsp;uniform,<br>
i.e.&nbsp;the&nbsp;probability&nbsp;of&nbsp;each&nbsp;value&nbsp;is&nbsp;equal&nbsp;to&nbsp;1&nbsp;/&nbsp;#values;<br>
if&nbsp;the&nbsp;sequence&nbsp;is&nbsp;empty,&nbsp;then&nbsp;an&nbsp;exception&nbsp;is&nbsp;raised</tt></dd></dl>

<dl><dt><a name="Alea-fromValFreqsDictArgs"><strong>fromValFreqsDictArgs</strong></a>(**probDict)</dt><dd><tt>static&nbsp;method,&nbsp;same&nbsp;as&nbsp;fromValFreqsDict,&nbsp;excepting&nbsp;that&nbsp;the&nbsp;dictionary<br>
is&nbsp;passed&nbsp;in&nbsp;a&nbsp;**kwargs&nbsp;style</tt></dd></dl>

<dl><dt><a name="Alea-if_"><strong>if_</strong></a>(condLea, thenLea, elseLea)</dt><dd><tt>returns&nbsp;an&nbsp;instance&nbsp;of&nbsp;Blea&nbsp;representing&nbsp;the&nbsp;conditional&nbsp;probability&nbsp;table<br>
giving&nbsp;thenLea&nbsp;&nbsp;if&nbsp;condLea&nbsp;is&nbsp;true<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;elseLea&nbsp;&nbsp;otherwise<br>
this&nbsp;is&nbsp;a&nbsp;convenience&nbsp;method&nbsp;equivalent&nbsp;to&nbsp;<br>
&nbsp;&nbsp;<a href="lea.html#Lea">Lea</a>.<a href="#Alea-buildCPT">buildCPT</a>((condLea,thenLea),(None,elseLea))</tt></dd></dl>

<dl><dt><a name="Alea-interval"><strong>interval</strong></a>(fromVal, toVal)</dt><dd><tt>static&nbsp;method,&nbsp;returns&nbsp;an&nbsp;<a href="#Alea">Alea</a>&nbsp;instance&nbsp;representing&nbsp;a&nbsp;uniform&nbsp;probability<br>
distribution,&nbsp;for&nbsp;all&nbsp;the&nbsp;integers&nbsp;in&nbsp;the&nbsp;interval&nbsp;[fromVal,toVal]</tt></dd></dl>

<dl><dt><a name="Alea-max"><strong>max</strong></a>(*args)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Flea&nbsp;instance&nbsp;giving&nbsp;the&nbsp;probabilities&nbsp;to&nbsp;have&nbsp;the&nbsp;maximum<br>
value&nbsp;of&nbsp;each&nbsp;combination&nbsp;of&nbsp;the&nbsp;given&nbsp;args;<br>
if&nbsp;some&nbsp;elements&nbsp;of&nbsp;args&nbsp;are&nbsp;not&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instances,&nbsp;then&nbsp;these&nbsp;are&nbsp;coerced<br>
to&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance&nbsp;with&nbsp;probability&nbsp;1;<br>
the&nbsp;returned&nbsp;distribution&nbsp;keeps&nbsp;dependencies&nbsp;with&nbsp;args&nbsp;but&nbsp;the&nbsp;<br>
calculation&nbsp;could&nbsp;be&nbsp;prohibitively&nbsp;slow&nbsp;(exponential&nbsp;complexity);<br>
for&nbsp;a&nbsp;more&nbsp;efficient&nbsp;implemetation,&nbsp;assuming&nbsp;that&nbsp;dependencies&nbsp;are&nbsp;not<br>
needed,&nbsp;see&nbsp;<a href="lea.html#Lea">Lea</a>.fastMax&nbsp;method</tt></dd></dl>

<dl><dt><a name="Alea-min"><strong>min</strong></a>(*args)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Flea&nbsp;instance&nbsp;giving&nbsp;the&nbsp;probabilities&nbsp;to&nbsp;have&nbsp;the&nbsp;minimum<br>
value&nbsp;of&nbsp;each&nbsp;combination&nbsp;of&nbsp;the&nbsp;given&nbsp;args;<br>
if&nbsp;some&nbsp;elements&nbsp;of&nbsp;args&nbsp;are&nbsp;not&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instances,&nbsp;then&nbsp;these&nbsp;are&nbsp;coerced<br>
to&nbsp;a&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;instance&nbsp;with&nbsp;probability&nbsp;1;<br>
the&nbsp;returned&nbsp;distribution&nbsp;keeps&nbsp;dependencies&nbsp;with&nbsp;args&nbsp;but&nbsp;the&nbsp;<br>
calculation&nbsp;could&nbsp;be&nbsp;prohibitively&nbsp;slow&nbsp;(exponential&nbsp;complexity);<br>
for&nbsp;a&nbsp;more&nbsp;efficient&nbsp;implemetation,&nbsp;assuming&nbsp;that&nbsp;dependencies&nbsp;are&nbsp;not<br>
needed,&nbsp;see&nbsp;<a href="lea.html#Lea">Lea</a>.fastMin&nbsp;method</tt></dd></dl>

<dl><dt><a name="Alea-reduce"><strong>reduce</strong></a>(op, args)</dt><dd><tt>returns&nbsp;a&nbsp;new&nbsp;Flea&nbsp;instance&nbsp;that&nbsp;join&nbsp;the&nbsp;given&nbsp;args&nbsp;with&nbsp;the&nbsp;given<br>
function&nbsp;op,&nbsp;from&nbsp;left&nbsp;to&nbsp;right;<br>
requires&nbsp;that&nbsp;op&nbsp;is&nbsp;a&nbsp;2-ary&nbsp;function,&nbsp;accepting&nbsp;self's&nbsp;values&nbsp;as&nbsp;arguments;<br>
requires&nbsp;that&nbsp;args&nbsp;contains&nbsp;at&nbsp;least&nbsp;one&nbsp;element</tt></dd></dl>

<hr>
Data descriptors inherited from <a href="lea.html#Lea">lea.Lea</a>:<br>
<dl><dt><strong>data</strong></dt>
</dl>
<dl><dt><strong>false</strong></dt>
<dd><tt>Alea&nbsp;is&nbsp;a&nbsp;Lea&nbsp;subclass,&nbsp;which&nbsp;instance&nbsp;is&nbsp;defined&nbsp;by&nbsp;explicit&nbsp;probability&nbsp;distribution&nbsp;data.<br>
An&nbsp;Alea&nbsp;instance&nbsp;is&nbsp;defined&nbsp;by&nbsp;given&nbsp;value-probability&nbsp;pairs.&nbsp;Each&nbsp;probability&nbsp;is<br>
defined&nbsp;as&nbsp;a&nbsp;positive&nbsp;"counter"&nbsp;or&nbsp;"weight"&nbsp;integer,&nbsp;without&nbsp;upper&nbsp;limit.&nbsp;The&nbsp;actual<br>
probabilities&nbsp;are&nbsp;calculated&nbsp;by&nbsp;dividing&nbsp;the&nbsp;counters&nbsp;by&nbsp;the&nbsp;sum&nbsp;of&nbsp;all&nbsp;counters.</tt></dd>
</dl>
<dl><dt><strong>name</strong></dt>
</dl>
<dl><dt><strong>true</strong></dt>
<dd><tt>Alea&nbsp;is&nbsp;a&nbsp;Lea&nbsp;subclass,&nbsp;which&nbsp;instance&nbsp;is&nbsp;defined&nbsp;by&nbsp;explicit&nbsp;probability&nbsp;distribution&nbsp;data.<br>
An&nbsp;Alea&nbsp;instance&nbsp;is&nbsp;defined&nbsp;by&nbsp;given&nbsp;value-probability&nbsp;pairs.&nbsp;Each&nbsp;probability&nbsp;is<br>
defined&nbsp;as&nbsp;a&nbsp;positive&nbsp;"counter"&nbsp;or&nbsp;"weight"&nbsp;integer,&nbsp;without&nbsp;upper&nbsp;limit.&nbsp;The&nbsp;actual<br>
probabilities&nbsp;are&nbsp;calculated&nbsp;by&nbsp;dividing&nbsp;the&nbsp;counters&nbsp;by&nbsp;the&nbsp;sum&nbsp;of&nbsp;all&nbsp;counters.</tt></dd>
</dl>
<dl><dt><strong>zero</strong></dt>
<dd><tt>Alea&nbsp;is&nbsp;a&nbsp;Lea&nbsp;subclass,&nbsp;which&nbsp;instance&nbsp;is&nbsp;defined&nbsp;by&nbsp;explicit&nbsp;probability&nbsp;distribution&nbsp;data.<br>
An&nbsp;Alea&nbsp;instance&nbsp;is&nbsp;defined&nbsp;by&nbsp;given&nbsp;value-probability&nbsp;pairs.&nbsp;Each&nbsp;probability&nbsp;is<br>
defined&nbsp;as&nbsp;a&nbsp;positive&nbsp;"counter"&nbsp;or&nbsp;"weight"&nbsp;integer,&nbsp;without&nbsp;upper&nbsp;limit.&nbsp;The&nbsp;actual<br>
probabilities&nbsp;are&nbsp;calculated&nbsp;by&nbsp;dividing&nbsp;the&nbsp;counters&nbsp;by&nbsp;the&nbsp;sum&nbsp;of&nbsp;all&nbsp;counters.</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="lea.html#Lea">lea.Lea</a>:<br>
<dl><dt><strong>Error</strong> = &lt;class 'lea.Error'&gt;<dd><tt>exception&nbsp;representing&nbsp;any&nbsp;violation&nbsp;of&nbsp;requirements&nbsp;of&nbsp;<a href="lea.html#Lea">Lea</a>&nbsp;methods</tt></dl>

</td></tr></table></td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#eeaa77">
<td colspan=3 valign=bottom>&nbsp;<br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Functions</strong></big></font></td></tr>
    
<tr><td bgcolor="#eeaa77"><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</tt></td><td>&nbsp;</td>
<td width="100%"><dl><dt><a name="-bisect_left"><strong>bisect_left</strong></a>(...)</dt><dd><tt><a href="#-bisect_left">bisect_left</a>(a,&nbsp;x[,&nbsp;lo[,&nbsp;hi]])&nbsp;-&gt;&nbsp;index<br>
&nbsp;<br>
Return&nbsp;the&nbsp;index&nbsp;where&nbsp;to&nbsp;insert&nbsp;item&nbsp;x&nbsp;in&nbsp;list&nbsp;a,&nbsp;assuming&nbsp;a&nbsp;is&nbsp;sorted.<br>
&nbsp;<br>
The&nbsp;return&nbsp;value&nbsp;i&nbsp;is&nbsp;such&nbsp;that&nbsp;all&nbsp;e&nbsp;in&nbsp;a[:i]&nbsp;have&nbsp;e&nbsp;&lt;&nbsp;x,&nbsp;and&nbsp;all&nbsp;e&nbsp;in<br>
a[i:]&nbsp;have&nbsp;e&nbsp;&gt;=&nbsp;x.&nbsp;&nbsp;So&nbsp;if&nbsp;x&nbsp;already&nbsp;appears&nbsp;in&nbsp;the&nbsp;list,&nbsp;i&nbsp;points&nbsp;just<br>
before&nbsp;the&nbsp;leftmost&nbsp;x&nbsp;already&nbsp;there.<br>
&nbsp;<br>
Optional&nbsp;args&nbsp;lo&nbsp;(default&nbsp;0)&nbsp;and&nbsp;hi&nbsp;(default&nbsp;len(a))&nbsp;bound&nbsp;the<br>
slice&nbsp;of&nbsp;a&nbsp;to&nbsp;be&nbsp;searched.</tt></dd></dl>
 <dl><dt><a name="-bisect_right"><strong>bisect_right</strong></a>(...)</dt><dd><tt>bisect(a,&nbsp;x[,&nbsp;lo[,&nbsp;hi]])&nbsp;-&gt;&nbsp;index<br>
<a href="#-bisect_right">bisect_right</a>(a,&nbsp;x[,&nbsp;lo[,&nbsp;hi]])&nbsp;-&gt;&nbsp;index<br>
&nbsp;<br>
Return&nbsp;the&nbsp;index&nbsp;where&nbsp;to&nbsp;insert&nbsp;item&nbsp;x&nbsp;in&nbsp;list&nbsp;a,&nbsp;assuming&nbsp;a&nbsp;is&nbsp;sorted.<br>
&nbsp;<br>
The&nbsp;return&nbsp;value&nbsp;i&nbsp;is&nbsp;such&nbsp;that&nbsp;all&nbsp;e&nbsp;in&nbsp;a[:i]&nbsp;have&nbsp;e&nbsp;&lt;=&nbsp;x,&nbsp;and&nbsp;all&nbsp;e&nbsp;in<br>
a[i:]&nbsp;have&nbsp;e&nbsp;&gt;&nbsp;x.&nbsp;&nbsp;So&nbsp;if&nbsp;x&nbsp;already&nbsp;appears&nbsp;in&nbsp;the&nbsp;list,&nbsp;i&nbsp;points&nbsp;just<br>
beyond&nbsp;the&nbsp;rightmost&nbsp;x&nbsp;already&nbsp;there<br>
&nbsp;<br>
Optional&nbsp;args&nbsp;lo&nbsp;(default&nbsp;0)&nbsp;and&nbsp;hi&nbsp;(default&nbsp;len(a))&nbsp;bound&nbsp;the<br>
slice&nbsp;of&nbsp;a&nbsp;to&nbsp;be&nbsp;searched.</tt></dd></dl>
 <dl><dt><a name="-exp"><strong>exp</strong></a>(...)</dt><dd><tt><a href="#-exp">exp</a>(x)<br>
&nbsp;<br>
Return&nbsp;e&nbsp;raised&nbsp;to&nbsp;the&nbsp;power&nbsp;of&nbsp;x.</tt></dd></dl>
 <dl><dt><a name="-log"><strong>log</strong></a>(...)</dt><dd><tt><a href="#-log">log</a>(x[,&nbsp;base])<br>
&nbsp;<br>
Return&nbsp;the&nbsp;logarithm&nbsp;of&nbsp;x&nbsp;to&nbsp;the&nbsp;given&nbsp;base.<br>
If&nbsp;the&nbsp;base&nbsp;not&nbsp;specified,&nbsp;returns&nbsp;the&nbsp;natural&nbsp;logarithm&nbsp;(base&nbsp;e)&nbsp;of&nbsp;x.</tt></dd></dl>
 <dl><dt><a name="-sqrt"><strong>sqrt</strong></a>(...)</dt><dd><tt><a href="#-sqrt">sqrt</a>(x)<br>
&nbsp;<br>
Return&nbsp;the&nbsp;square&nbsp;root&nbsp;of&nbsp;x.</tt></dd></dl>
</td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#55aa55">
<td colspan=3 valign=bottom>&nbsp;<br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Data</strong></big></font></td></tr>
    
<tr><td bgcolor="#55aa55"><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</tt></td><td>&nbsp;</td>
<td width="100%"><strong>LOG2</strong> = 0.6931471805599453</td></tr></table>
</body></html>